﻿// ----------------------------------------------------------------------------------------
// Author:                    Joaquín López y Magaly Vargas 
// Company:                   ALBALIA INTERACTIVA S.L.
// Assembly version:          1.0.0.0
// Date:                      05/02/2009
// Time:                      18:02
// Solution Name:             FacturaeAdd-in
// Solution Filename:         FacturaeAdd-in.sln
// Solution FullFilename:     C:\Ribbon_Facturae\FacturaeAdd-in.sln
// Project Name:              FacturaeAdd-in
// Project Filename:          FacturaeAdd-in.csproj
// Project FullFilename:      C:\Ribbon_Facturae\FacturaeAdd-in\FacturaeAdd-in.csproj
// Project Item Name:         XmlFileMngParser.cs
// Project Item Filename:     XmlFileMngParser.cs
// Project Item FullFilename: C:\Ribbon_Facturae\FacturaeAdd-in\XmlMngFiles\XmlFileMngParser.cs
// Project Item Kind:         Código
// Purpose:                   Controlar la creacion, el registro, actualizacion eliminacion  y accesso de la bitácora y los archivos de gestión
//Copyright © 2008 - 2009 Albalia Interactiva S.L. Reservados todos los derechos.
// ----------------------------------------------------------------------------------------


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.Windows.Forms;
using System.Xml;
using System.IO;
using System.Globalization;

namespace FacturaeAdd_in.XmlMngFiles
{
    /// <summary>
    /// clase que provee los  metodos para controlar la representacion de objetos .net a xml y viceversa
    /// </summary>
    public class XmlFileMngParser
    {
        #region fields

        /// <summary>
        /// Atributo de tipo XmlFileMngRegistry que hace referencia al archivo de gestion de facuras
        /// </summary>
        XmlFileMngRegistry registry = null;

        /// <summary>
        /// Atributo de tipo XmlFileMngRecord que hace referencia a un registro del archivo
        /// </summary>
        XmlFileMngRecord mngfilerecord = null;

        /// <summary>
        /// Atributo de tipo XmlInvoiceRecord que hace referencia a un registro de una factura
        /// </summary>
        XmlInvoiceRecord mngfile = null;

        /// <summary>
        /// Atributo de tipo ControlMessages que hace referencia a una instancia sobre la clase que muestra los mensajes
        /// </summary>
        ControlMessages msg = ControlMessages.getInstance();        
        
        #endregion


        #region contructors

        public XmlFileMngParser()
        {}

        #endregion
                

        #region private methods

        /// <summary>
        /// crea la representacion .net un nodo MonthFileMng, que contiene los datos del mes al que 
        /// corresponde una facturae
        /// </summary>
        /// <param name="id">nombre del mes  a registrar</param>
        /// <returns> un nuevo mes creado con lista de facturas inicializada</returns>
        private Month createNewXmlMonthNode(string id)
        {
            return new Month(id);
        }

        /// <summary>
        /// crea la representacion .net un nodo YearFileMng, que contiene los datos del año al que 
        /// corresponde una facturae
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        private Year createNewXmlYearNode(string id)
        {
            return new Year(id);
        }

        #endregion
        

        #region public methods

        /// <summary>
        /// crea la representacion .net de un nodo XmlInvoice, que contiene los datos básicos de la facturae
        /// </summary>
        /// <param name="id">identificador de la facturae</param>
        /// <param name="status">tipo o estado de la facturae</param>
        /// <returns>devuelve un nuevo nodo de factura con los datos pasados por parámetros</returns>
        public XmlInvoice createNewXmlInvoiceNode(string serie,string n_Factura,string cif, string customerName,string customerFirstName,string customerSecondName, string issuername,string issuerFirstName,string issuerSecondName,string fecha, string totalImport, string status,string marca, string path,string invoiceType)
        {
            return new XmlInvoice(serie, n_Factura, cif, customerName, customerFirstName, customerSecondName, issuername, issuerFirstName, issuerSecondName, fecha, totalImport, status, marca, path, invoiceType);
        }

        /// <summary>
        /// crea un nuevo fichero de gestion xml, con el path y los datos dados 
        /// </summary>
        /// <param name="xmlfilemngrecord">registro a almacenar en el fichero</param>
        /// <param name="xmlfilemngpath">directorio donde se almacenara el archivo</param>
        public void createNewXmlFileMng(XmlInvoiceRecord xmlfilemngrecord,string xmlfilemngpath)
        {
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(XmlInvoiceRecord));
                //MessageBox.Show(msg.getMessage(ControlMessages.Msg.InfoSavedRegistry), msg.getMessage(ControlMessages.Msg.CaptionMngFile), MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                System.IO.StreamWriter w = new System.IO.StreamWriter(xmlfilemngpath);
                serializer.Serialize(w, xmlfilemngrecord);
                w.Close();

            }
            catch (Exception) 
            {
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorCreatingMngFile),msg.getMessage(ControlMessages.Msg.CaptionCreatingMngFile), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);

            }
        }


        /// <summary>
        /// agrega un nuevo registro de factura a un fichero de gestión, si existe obtiene el objeto y le agrega el 
        /// registro, sino crea un nuevo fichero con el registro dado
        /// </summary>
        /// <param name="xmlfilemngpath">path del archivo de gestion donde se agregará el nuevo registro</param>
        /// <param name="xmlInv">registro a agregar</param>

         public void addNewXmlInvoiceRecord(string year, string month,string status,XmlInvoice xmlInv) 
        {

            string fullpath = getPath(status);

            fullpath = String.Concat(fullpath, year, month, ".xml");

            XmlInvoiceRecord xmlInvRec = getXmlFileMng(fullpath);

            if (xmlInvRec == null)
                {
                    //se crea los objetos necesarios para crear un nuevo XmlInvoiceRecord
                    Year yearxml = new Year(year);
                    Month monthxml = new Month(month);
                    yearxml.newMonth(monthxml);
                    xmlInvRec = new XmlInvoiceRecord();
                    xmlInvRec.newYear(yearxml);
                    try
                    {
                        xmlInvRec.year.month.newInvoice(xmlInv);
                    }
                    catch (Exception e)
                    {
                        
                        throw e;
                    }
                    
                    //se crea el fichero de gestion con el nuevo registro
                    createNewXmlFileMng(xmlInvRec, fullpath);
                    XmlFileMngRecord record = new XmlFileMngRecord(year, month, status, fullpath);
                    addNewXmlFileMngRecord(record);

                }
                else
                {
                    //se obtiene el fichero y se  le agrega el registro
                    try
                    {
                        xmlInvRec.year.month.newInvoice(xmlInv);
                        createNewXmlFileMng(xmlInvRec, fullpath);
                    }
                    catch (Exception e)
                    {
                        
                        throw e;
                    }
                    
                }
        }

        /// <summary>
        /// devuelve el directorio donde se encuentra el archivos de gestion del estado indicado
        /// </summary>
        /// <param name="status">estado del que se busca el archivo de gestion</param>
        /// <returns>el directorio del archivo de gestion</returns>
         private string getPath(string status)
         {
             if (status.ToLower().Equals("ISSUED".ToLower()))
                 return Globals.ThisAddIn.EnvironmentVariable +  Paths.IssuedPath;
             else if (status.ToLower().Equals("RECEIVED".ToLower()))
                 return  Globals.ThisAddIn.EnvironmentVariable + Paths.ReceivedPath;
             else
                 return Globals.ThisAddIn.EnvironmentVariable + Paths.DraftPath;

         }


        
        /// <summary>
        /// obtiene un objeto de la clase XmlInvoiceRecord que representa al fichero de gestion Xml
        /// </summary>
        /// <param name="path">directorio en el que se encuentra el fichero de gestion Xml </param>
        /// <returns>un objeto de la clase XmlInvoiceRecord con los valores obtenidos del archivo xml, retorna null si no logra deserealizar el archivo</returns>
        public  XmlInvoiceRecord getXmlFileMng(string path)
        {
            try
            {
                if (System.IO.File.Exists(path))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(XmlInvoiceRecord));
                    System.IO.StreamReader r = new System.IO.StreamReader(path);
                    XmlInvoiceRecord copia = (XmlInvoiceRecord)serializer.Deserialize(r);
                    r.Close();
                    return copia;
                }
                else
                {
                    return null;
                }

            }
            catch (Exception)
            {
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorDeserealizarMngFile),msg.getMessage(ControlMessages.Msg.CaptionMngFile), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);

                return null;
            }

        }

        /// <summary>
        /// Agrega en la bitacora el registro de un nuevo fichero de gestion
        /// </summary>
        /// <param name="xmlFMRec">registro a incluir</param>
        public void addNewXmlFileMngRecord(XmlFileMngRecord xmlFMRec)
        {
            
            XmlFileMngRegistry xmlInvReg = getXmlFileMngRegistry();

            if (xmlInvReg == null)
            {
                //se crea los objetos necesarios para crear un nuevo XmlInvoiceRecord
                xmlInvReg = new XmlFileMngRegistry();
                xmlInvReg.XmlInvoice.Add(xmlFMRec);
                
                //se crea el fichero de registro de archivos de gestion con el nuevo registro
                createNewXmlFileMngRegistry(xmlInvReg);
            }
            else
            {
                //se obtiene el fichero y se  le agrega el registro
                xmlInvReg.XmlInvoice.Add(xmlFMRec);
                createNewXmlFileMngRegistry(xmlInvReg);
            }

        }
        
        /// <summary>
        /// obtiene la representacion .net del fichero de registro de archivos de gestion xml
        /// </summary>
        /// <param name="path">path donde se ubica el fichero</param>
        /// <returns>el fichero de registro de archivos de control</returns>
        public XmlFileMngRegistry getXmlFileMngRegistry()
        {
            try
            {
                if (System.IO.File.Exists(Globals.ThisAddIn.EnvironmentVariable + Paths.BitacoraPath))
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(XmlFileMngRegistry));
                    System.IO.StreamReader r = new System.IO.StreamReader(Globals.ThisAddIn.EnvironmentVariable + Paths.BitacoraPath);
                    XmlFileMngRegistry copia = (XmlFileMngRegistry)serializer.Deserialize(r);
                    r.Close();
                    return copia;
                }
                else
                {

                    
                    return null;
                }

            }
            catch (Exception)
            {
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorDeserealizarMngFileReg),msg.getMessage(ControlMessages.Msg.CaptionMngFileReg), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);

                return null;
            }
        }
        
    /// <summary>
    /// crea un nuevo fichero de registro de archivos de gestion xml 
    /// </summary>
    /// <param name="xmlFMReg"></param>
        public void createNewXmlFileMngRegistry(XmlFileMngRegistry xmlFMReg)
        {
            try
            {
                XmlSerializer serializer = new XmlSerializer(typeof(XmlFileMngRegistry));
                //MessageBox.Show(msg.getMessage(ControlMessages.Msg.InfoRegistryFileCreated),msg.getMessage(ControlMessages.Msg.CaptionMngFileReg), MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                System.IO.StreamWriter w = new System.IO.StreamWriter(Globals.ThisAddIn.EnvironmentVariable + Paths.BitacoraPath);
                serializer.Serialize(w, xmlFMReg);
                w.Close();

            }
            catch (Exception)
            {
                MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorCreatingMngFileReg), msg.getMessage(ControlMessages.Msg.CaptionMngFileReg), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);

            }
        }

        /// <summary>
        /// verifica si el archivo con los parametros dados existe
        /// </summary>
        /// <param name="year">año del que se buscan las facturas</param>
        /// <param name="month">mes del que se buscan las facturas</param>
        /// <param name="status">status de las facturas buscadas</param>
        /// <returns>el fichero si existe de lo contrario retorna null</returns>
        public XmlInvoiceRecord XmlFileMngExist(string year, string month,int monthIndex, string status)
        {
            //abre el archivo de registro de los ficheros de gestión xml
            registry = getXmlFileMngRegistry();
            if (registry != null)
            {
                //verifica en la bitacora si existe un registro del fichero de gestion  
                mngfilerecord = registry.searchRegManagementFile(year, month,monthIndex, status);
                if (mngfilerecord == null)
                {
                    throw new Exception(msg.getMessage(ControlMessages.Msg.InfoNoneInvoiceFound));
                    //MessageBox.Show(msg.getMessage(ControlMessages.Msg.InfoNoneInvoiceFound), msg.getMessage(ControlMessages.Msg.CaptionInvoiceSearch), MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
                }
                else
                {
                    //verifica que el archivo de gestion exista fisicamente
                    if (!System.IO.File.Exists(mngfilerecord.Path))
                    {
                        throw new Exception(msg.getMessage(ControlMessages.Msg.ErrorMngFileNotFound));
                        //MessageBox.Show(msg.getMessage(ControlMessages.Msg.ErrorMngFileNotFound), msg.getMessage(ControlMessages.Msg.CaptionMngFile), MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                    }
                    else
                    {
                        //obtiene el fichero de gestion 
                        mngfile = getXmlFileMng(mngfilerecord.Path);
                    }
                }

            }
            else
            {
                mngfile = null;
            }

            
            return mngfile;
        }


        /// <summary>
        /// obtiene el listado de facturas que corresponden a los datos indicados en los parametros
        /// </summary>
        /// <param name="status">estado de la factura: Issued, Received ó Draft</param>
        /// <param name="customer">cliente de la factura</param>
        /// <param name="issuer">emisor de la factura</param>
        /// <param name="issuerIndex">indice del combobox del emisor seleccionado</param>
        /// <param name="customerIndex">indice del combobox del cliente seleccionado</param>
        /// <param name="amount">importe total de la factura</param>
        /// <param name="condicion">para busquedas del importe (mayor,menor o igual qué) </param>
        /// <param name="cobrada">estado de la factura</param>
        /// <param name="pagada">estado de la factura</param>
        /// <param name="rechazada">estado de la factura</param>
        /// <returns>el listado de facturas coincidentes, </returns>
        public List<XmlInvoice> getInvoicesList(int status, string customer, string issuer,int issuerIndex,int customerIndex, string amount, int condicion,string cobrada,string pagada,string rechazada)
        {
            XmlInvoiceRecord mngFile;

            List<XmlInvoice> invoiceList = new List<XmlInvoice>();

            XmlFileMngRegistry registry = getXmlFileMngRegistry();         

            if (registry != null)
            {

                switch (status)
                {
                    case -1:
                        foreach (XmlFileMngRecord item in registry.XmlInvoice)
                        {
                            if (System.IO.File.Exists(item.Path))
                            {
                                mngFile = getXmlFileMng(item.Path);
                                foreach (XmlInvoice item2 in mngFile.year.month.InvoiceList)
                                {
                                    if (getInvoice(item2, issuer, customer, amount, condicion, issuerIndex, customerIndex,cobrada,pagada,rechazada))
                                        invoiceList.Add(item2);
                                }
                            }
                        }
                        break;

                    case 0:
                        invoiceList = getInvoiceByStatus("ISSUED", customer, issuer, issuerIndex, customerIndex, amount, condicion, cobrada, pagada, rechazada); break;
                    case 1:
                        invoiceList = getInvoiceByStatus("RECEIVED", customer, issuer, issuerIndex, customerIndex, amount, condicion, cobrada, pagada, rechazada); break;
                    case 2:
                        invoiceList = getInvoiceByStatus("DRAFT", customer, issuer, issuerIndex, customerIndex, amount, condicion, cobrada, pagada, rechazada); break;



                }
            }
            return invoiceList;
        }


        public bool getInvoice(XmlInvoice item2, string issuer, string customer, string amount, int condicion, int issuerIndex, int customerIndex, string cobrada, string pagada, string rechazada)
        {
            bool band = false;

            //CultureInfo culture = CultureInfo.CurrentCulture;
            CultureInfo culture = Globals.ThisAddIn.InvoiceCulture;
            NumberFormatInfo number = culture.NumberFormat;            
            double tAmount = 0;

            string nombreCompletoIssuer = string.Concat(item2.IssuerName, " ", item2.IssuerFirstName, " ", item2.IssuerSecondName);
            string nombreCompletoCustomer = string.Concat(item2.CustomerName, " ", item2.CustomerFirstName, " ", item2.CustomerSecondName);


            try
            {
                tAmount = double.Parse(amount, number);
            }
            catch (Exception) { }
            

            switch (condicion)
            {

                case -1:

                    if ((string.IsNullOrEmpty(issuer) || issuer.ToUpper().Trim().Equals(nombreCompletoIssuer.ToUpper().Trim()) || issuerIndex == 0) && (string.IsNullOrEmpty(customer) || customer.ToUpper().Trim().Equals(nombreCompletoCustomer.ToUpper().Trim()) || customerIndex == 0) && ((!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && cobrada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim())) || (string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim())) || (!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && !string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && !string.IsNullOrEmpty(item2.Marca.ToUpper().Trim())) || (!string.IsNullOrEmpty(pagada.ToUpper().Trim()) && (pagada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (!string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && (rechazada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (string.IsNullOrEmpty(item2.Marca.ToUpper().Trim()) && string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()))))
                        band = true;                    
                    break;

                case 0:

                    if ((string.IsNullOrEmpty(issuer) || issuer.ToUpper().Trim().Equals(nombreCompletoIssuer.ToUpper().Trim()) || issuerIndex == 0) && (string.IsNullOrEmpty(customer) || customer.ToUpper().Trim().Equals(nombreCompletoCustomer.ToUpper().Trim()) || customerIndex == 0) && (string.IsNullOrEmpty(amount) || double.Parse(item2.TotalImport, number) > tAmount) && ((!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && cobrada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim())) || (string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim())) || (!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && !string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && !string.IsNullOrEmpty(item2.Marca.ToUpper().Trim())) || (!string.IsNullOrEmpty(pagada.ToUpper().Trim()) && (pagada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (!string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && (rechazada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (string.IsNullOrEmpty(item2.Marca.ToUpper().Trim()) && string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()))))
                        band = true;
                    break;

                case 1:

                    if ((string.IsNullOrEmpty(issuer) || issuer.ToUpper().Trim().Equals(nombreCompletoIssuer.ToUpper().Trim()) || issuerIndex == 0) && (string.IsNullOrEmpty(customer) || customer.ToUpper().Trim().Equals(nombreCompletoCustomer.ToUpper().Trim()) || customerIndex == 0) && (string.IsNullOrEmpty(amount) || double.Parse(item2.TotalImport, number) < tAmount) && ((!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && cobrada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim())) || (string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim())) || (!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && !string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && !string.IsNullOrEmpty(item2.Marca.ToUpper().Trim())) || (!string.IsNullOrEmpty(pagada.ToUpper().Trim()) && (pagada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (!string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && (rechazada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (string.IsNullOrEmpty(item2.Marca.ToUpper().Trim()) && string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()))))
                        band = true;
                    break;


                case 2:

                    if ((string.IsNullOrEmpty(issuer) || issuer.ToUpper().Trim().Equals(nombreCompletoIssuer.ToUpper().Trim()) || issuerIndex == 0) && (string.IsNullOrEmpty(customer) || customer.ToUpper().Trim().Equals(nombreCompletoCustomer.ToUpper().Trim()) || customerIndex == 0) && (string.IsNullOrEmpty(amount) || double.Parse(item2.TotalImport, number) == tAmount) && ((!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && cobrada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim())) || (string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim())) || (!string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && !string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && !string.IsNullOrEmpty(item2.Marca.ToUpper().Trim())) || (!string.IsNullOrEmpty(pagada.ToUpper().Trim()) && (pagada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (!string.IsNullOrEmpty(rechazada.ToUpper().Trim()) && (rechazada.ToUpper().Trim().Equals(item2.Marca.ToUpper().Trim()))) || (string.IsNullOrEmpty(item2.Marca.ToUpper().Trim()) && string.IsNullOrEmpty(cobrada.ToUpper().Trim()) && string.IsNullOrEmpty(pagada.ToUpper().Trim()) && string.IsNullOrEmpty(rechazada.ToUpper().Trim()))))
                        band = true;
                    break;
            }
            return band;
        }

        
        public List<XmlInvoice> getInvoiceByStatus(string status, string customer, string issuer, int issuerIndex, int customerIndex, string amount, int condicion, string cobrada, string pagada, string rechazada)
        {
            List<XmlInvoice> invoices = new List<XmlInvoice>();
            registry = getXmlFileMngRegistry();
            XmlInvoiceRecord mngFile = null;

            foreach (XmlFileMngRecord item in registry.XmlInvoice)
            {

                if (item.Status.ToUpper().Equals(status.ToUpper()))
                {
                    if (System.IO.File.Exists(item.Path))
                    {
                        mngFile = getXmlFileMng(item.Path);
                        foreach (XmlInvoice item2 in mngFile.year.month.InvoiceList)
                        {
                            if (getInvoice(item2, issuer, customer, amount, condicion, issuerIndex, customerIndex, cobrada,pagada,rechazada))
                                invoices.Add(item2);
                        }
                    }

                }
            }
            return invoices;
        }

       
        /// <summary>
        /// actualiza en el archivo de gestion el estado de la factura (cobrada-rechazada-pagada)
        /// </summary>
        /// <param name="serie">serie de la factura a actualizar</param>
        /// <param name="numFac">numero de la factura a actualizar</param>
        /// <param name="cif">nif del cliente de la factura</param>
        /// <param name="marca">valor a asignar al estado</param>
        /// <param name="path">directorio del ficehro de gestion</param>
        public void updateChangeMarca(string serie, string numFac, string cif, string marca, string path)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(path);
            XmlNodeList e = (XmlNodeList)doc.DocumentElement.GetElementsByTagName("XmlInvoice");
            bool encontrado = false;
            int i = 0;
            while (i < e.Count && !encontrado)
            {
                if (e.Item(i).Attributes.GetNamedItem("Serie").Value.Trim().Equals(serie.Trim()) && e.Item(i).Attributes.GetNamedItem("N_factura").Value.Trim().Equals(numFac.Trim()) && e.Item(i).Attributes.GetNamedItem("CIF").Value.Trim().Equals(cif.Trim()))
                {
                    e.Item(i).Attributes.GetNamedItem("Marca").Value = marca;
                    encontrado = true;
                }
                else
                {
                    i++;
                }
            }
            doc.Save(path);
        }

        /// <summary>
        /// Busca y elimina una factura del fichero de gestion
        /// </summary>
        /// <param name="serie">serie de la factura a actualizar</param>
        /// <param name="numFac">numero de la factura a actualizar</param>
        /// <param name="cif">nif del cliente de la factura</param>
        /// <param name="path">directorio del ficehro de gestion</param>      
        public void removeInvoive(string serie, string numFac, string cif, string path)
        {
            try
            {
                XmlDocument doc = new XmlDocument();
                try
                {
                    doc.Load(path);
                }
                catch (Exception)
                {
                    return;
                }
                
                XmlNodeList e = (XmlNodeList)doc.DocumentElement.GetElementsByTagName("XmlInvoice");
                XmlNode invoiceNode = null;
                bool encontrado = false;
                int i = 0;
                while (i < e.Count && !encontrado)
                {
                    if (e.Item(i).Attributes.GetNamedItem("Serie").Value.Equals(serie) && e.Item(i).Attributes.GetNamedItem("N_factura").Value.Equals(numFac) && e.Item(i).Attributes.GetNamedItem("CIF").Value.Equals(cif))
                    {
                        invoiceNode = e.Item(i);
                        encontrado = true;
                    }
                    else
                    {
                        i++;
                    }
                }
                if (!(invoiceNode == null))
                {
                    if (File.Exists(invoiceNode.Attributes.GetNamedItem("Path").Value))
                    {
                        try
                        {
                            File.Delete(invoiceNode.Attributes.GetNamedItem("Path").Value);
                        }
                        catch (Exception)
                        {
                            throw new Exception("ErrorFileOpenNoDelete");
                        }
                        
                    }
                    doc.DocumentElement.ChildNodes.Item(0).ChildNodes.Item(0).ChildNodes.Item(0).RemoveChild(invoiceNode);
                    doc.Save(path);
                }

            }
            catch (Exception e) 
            {
                throw e;
            }
        }
        


        #endregion
    }
}
